package com.qf.CompletableFuture;

import java.util.Arrays;
import java.util.concurrent.*;

/**
 * 线程1执行完后，再去执行线程2
 */
public class Demo02 {

    // 1.创建一个自己的线程池
    private static ThreadPoolExecutor executors = new ThreadPoolExecutor(
            5, // 核心线程池,线程池中至少有5个线程
            15, // 线程池中的最大线程数量
            3,  // 空闲线程回收的时间
            TimeUnit.SECONDS, // 时间单位
            new ArrayBlockingQueue(20), // 线程池中的线程已经最大了，剩下的引用压入队列等待空闲线程
            Executors.defaultThreadFactory(),  // 创建线程的默认工厂
            new ThreadPoolExecutor.AbortPolicy() // 拒绝策略，队列的长度满了以后执行的拒绝策略
    );

    public static void main(String[] args) throws ExecutionException, InterruptedException {


        // 1.先执行线程1
//        CompletableFuture.runAsync(() -> {
//            System.out.println("线程1先执行，没有返回值");
//            int i = 10 / 0;
//        }, executors)
//                .whenCompleteAsync((data, exc) -> { // 等上一个线程执行完成后在调用
//                    // data:是上一个线程的返回值结果，如果没有就是null，
//                    // exc:是上一个线程的异常对象，如果没有就是null
//                    System.out.println("线程2开始执行，data:" + data + ",exc:" + exc);
//                }, executors);


        // 有返回结果的
        CompletableFuture<Integer> exceptionally = CompletableFuture.supplyAsync(() -> {
            System.out.println("线程1执行计算任务，有返回结果");
            int i = 10 / 0;
            return 10 + 20;
        }, executors).whenCompleteAsync((data, resp) -> {
            System.out.println("线程2：data:" + data + ",resp:" + resp);
        }, executors).exceptionally((exc) -> { // 线程1中出现异常后执行，没有执行异常不执行
            System.out.println("exceptionally: data:" + exc);
            return 10; // 默认值的
        }).handle((data, resp) -> {
            // data:就是线程1的返回值，如果出现异常了就是exceptionally返回值
            System.out.println("handle:data:" + data);
            return 100;
        });
        System.out.println("返回的结果：" + exceptionally.get());

//
//        System.out.println("Demo02.main");
//
//        executors.shutdown(); // 关闭线程池
//        System.out.println("线程已关闭。。");
    }
}
